/**
 * 数据分析状态管理
 * 使用Pinia管理数据分析相关的状态和数据
 */
import { defineStore } from 'pinia';
import api from '@/api/index.js';

// 定义数据分析store
export const useAnalysisStore = defineStore('analysis', {
  // 状态数据
  state: () => ({
    // 销量排行数据
    salesRanking: [],
    // 评分分布数据
    ratingDistribution: [],
    // 热门关键词数据
    hotKeywords: [],
    // 市场趋势数据
    marketTrend: [],
    // 加载状态
    loading: {
      salesRanking: false,
      ratingDistribution: false,
      hotKeywords: false,
      marketTrend: false
    },
    // 过滤条件
    filter: {
      // 时间范围: week-本周, month-本月, year-本年, all-全部
      timeRange: 'month',
      // 分类ID，0表示全部分类
      categoryId: 0,
      // 图表类型: bar-柱状图, line-折线图, pie-饼图
      chartType: 'bar',
      // 是否开启对比模式
      compareMode: false,
      // 对比的分类ID
      compareCategoryId: 0
    },
    // 错误信息
    error: null
  }),
  
  // 计算属性
  getters: {
    // 获取时间范围文本
    timeRangeText: (state) => {
      const map = {
        'week': '本周',
        'month': '本月',
        'year': '本年',
        'all': '全部'
      };
      return map[state.filter.timeRange] || '本月';
    },
    
    // 判断是否有销量排行数据
    hasSalesRanking: (state) => state.salesRanking && state.salesRanking.length > 0,
    
    // 判断是否有评分分布数据
    hasRatingDistribution: (state) => state.ratingDistribution && state.ratingDistribution.length > 0,
    
    // 判断是否有热门关键词数据
    hasHotKeywords: (state) => state.hotKeywords && state.hotKeywords.length > 0,
    
    // 判断是否有市场趋势数据
    hasMarketTrend: (state) => state.marketTrend && state.marketTrend.length > 0
  },
  
  // 操作方法
  actions: {
    /**
     * 设置过滤条件
     * @param {Object} filter 过滤条件
     */
    setFilter(filter) {
      this.filter = {
        ...this.filter,
        ...filter
      };
    },
    
    /**
     * 重置过滤条件
     */
    resetFilter() {
      this.filter = {
        timeRange: 'month',
        categoryId: 0,
        chartType: 'bar',
        compareMode: false,
        compareCategoryId: 0
      };
    },
    
    /**
     * 获取销量排行数据
     * @param {Object} params 查询参数，覆盖默认过滤条件
     * @returns {Promise<Array>} 销量排行数据
     */
    async fetchSalesRanking(params = {}) {
      try {
        this.loading.salesRanking = true;
        
        // 合并过滤条件和自定义参数
        const queryParams = {
          timeRange: this.filter.timeRange,
          categoryId: this.filter.categoryId,
          ...params
        };
        
        const res = await api.analysis.getSalesRanking(queryParams);
        
        if (res && res.data) {
          this.salesRanking = res.data;
          return res.data;
        } else {
          throw new Error('获取销量排行数据失败');
        }
      } catch (error) {
        this.error = error.message || '获取销量排行数据失败';
        console.error('获取销量排行数据失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.salesRanking = false;
      }
    },
    
    /**
     * 获取评分分布数据
     * @param {Object} params 查询参数，覆盖默认过滤条件
     * @returns {Promise<Array>} 评分分布数据
     */
    async fetchRatingDistribution(params = {}) {
      try {
        this.loading.ratingDistribution = true;
        
        // 合并过滤条件和自定义参数
        const queryParams = {
          timeRange: this.filter.timeRange,
          categoryId: this.filter.categoryId,
          ...params
        };
        
        const res = await api.analysis.getRatingDistribution(queryParams);
        
        if (res && res.data) {
          this.ratingDistribution = res.data;
          return res.data;
        } else {
          throw new Error('获取评分分布数据失败');
        }
      } catch (error) {
        this.error = error.message || '获取评分分布数据失败';
        console.error('获取评分分布数据失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.ratingDistribution = false;
      }
    },
    
    /**
     * 获取热门关键词数据
     * @param {Object} params 查询参数，覆盖默认过滤条件
     * @returns {Promise<Array>} 热门关键词数据
     */
    async fetchHotKeywords(params = {}) {
      try {
        this.loading.hotKeywords = true;
        
        // 合并过滤条件和自定义参数
        const queryParams = {
          timeRange: this.filter.timeRange,
          categoryId: this.filter.categoryId,
          ...params
        };
        
        const res = await api.analysis.getHotKeywords(queryParams);
        
        if (res && res.data) {
          this.hotKeywords = res.data;
          return res.data;
        } else {
          throw new Error('获取热门关键词数据失败');
        }
      } catch (error) {
        this.error = error.message || '获取热门关键词数据失败';
        console.error('获取热门关键词数据失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.hotKeywords = false;
      }
    },
    
    /**
     * 获取市场趋势数据
     * @param {Object} params 查询参数，覆盖默认过滤条件
     * @returns {Promise<Array>} 市场趋势数据
     */
    async fetchMarketTrend(params = {}) {
      try {
        this.loading.marketTrend = true;
        
        // 合并过滤条件和自定义参数
        const queryParams = {
          timeRange: this.filter.timeRange,
          categoryId: this.filter.categoryId,
          ...params
        };
        
        const res = await api.analysis.getMarketTrend(queryParams);
        
        if (res && res.data) {
          this.marketTrend = res.data;
          return res.data;
        } else {
          throw new Error('获取市场趋势数据失败');
        }
      } catch (error) {
        this.error = error.message || '获取市场趋势数据失败';
        console.error('获取市场趋势数据失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.marketTrend = false;
      }
    },
    
    /**
     * 对比模式下获取销量排行数据
     * @returns {Promise<Array>} 对比数据
     */
    async fetchCompareSalesRanking() {
      if (!this.filter.compareMode || !this.filter.compareCategoryId) {
        return [];
      }
      
      try {
        // 查询对比分类的数据
        const queryParams = {
          timeRange: this.filter.timeRange,
          categoryId: this.filter.compareCategoryId
        };
        
        const res = await api.analysis.getSalesRanking(queryParams);
        return res && res.data ? res.data : [];
      } catch (error) {
        console.error('获取对比销量排行数据失败:', error);
        return [];
      }
    },
    
    /**
     * 对比模式下获取评分分布数据
     * @returns {Promise<Array>} 对比数据
     */
    async fetchCompareRatingDistribution() {
      if (!this.filter.compareMode || !this.filter.compareCategoryId) {
        return [];
      }
      
      try {
        // 查询对比分类的数据
        const queryParams = {
          timeRange: this.filter.timeRange,
          categoryId: this.filter.compareCategoryId
        };
        
        const res = await api.analysis.getRatingDistribution(queryParams);
        return res && res.data ? res.data : [];
      } catch (error) {
        console.error('获取对比评分分布数据失败:', error);
        return [];
      }
    },
    
    /**
     * 对比模式下获取市场趋势数据
     * @returns {Promise<Array>} 对比数据
     */
    async fetchCompareMarketTrend() {
      if (!this.filter.compareMode || !this.filter.compareCategoryId) {
        return [];
      }
      
      try {
        // 查询对比分类的数据
        const queryParams = {
          timeRange: this.filter.timeRange,
          categoryId: this.filter.compareCategoryId
        };
        
        const res = await api.analysis.getMarketTrend(queryParams);
        return res && res.data ? res.data : [];
      } catch (error) {
        console.error('获取对比市场趋势数据失败:', error);
        return [];
      }
    },
    
    /**
     * 导出数据为CSV格式
     * @param {String} type 数据类型: sales, rating, keywords, trend
     * @returns {String} CSV格式数据
     */
    exportToCSV(type) {
      let data = [];
      let headers = [];
      
      switch (type) {
        case 'sales':
          headers = ['排名', '图书名称', '销量'];
          data = this.salesRanking.map((item, index) => [
            index + 1,
            item.bookName,
            item.salesCount
          ]);
          break;
          
        case 'rating':
          headers = ['评分', '数量', '比例(%)'];
          data = this.ratingDistribution.map(item => [
            item.rating,
            item.count,
            (item.percentage * 100).toFixed(2)
          ]);
          break;
          
        case 'keywords':
          headers = ['关键词', '热度', '搜索次数'];
          data = this.hotKeywords.map(item => [
            item.keyword,
            item.score,
            item.searchCount
          ]);
          break;
          
        case 'trend':
          headers = ['日期', '销量', '评分数量'];
          data = this.marketTrend.map(item => [
            item.date,
            item.salesCount,
            item.ratingCount
          ]);
          break;
          
        default:
          return '';
      }
      
      // 生成CSV内容
      const csvContent = [
        headers.join(','),
        ...data.map(row => row.join(','))
      ].join('\n');
      
      return csvContent;
    }
  }
});
